package leetcode._01_数组;

import org.junit.Test;

import java.util.Arrays;
import java.util.Comparator;

/**
 * @author pppppp
 * @date 2022/4/17 11:04
 * 给你两个版本号 version1 和 version2 ，请你比较它们。
 * 版本号由一个或多个修订号组成，各修订号由一个 '.' 连接。每个修订号由 多位数字 组成，可能包含 前导零 。
 * 每个版本号至少包含一个字符。
 * 修订号从左到右编号，下标从 0 开始，最左边的修订号下标为 0 ，下一个修订号下标为 1 ，以此类推。
 * <p>
 * 例如，2.5.33 和 0.1 都是有效的版本号。
 * 比较版本号时，请按从左到右的顺序依次比较它们的修订号。
 * 比较修订号时，只需比较 忽略任何前导零后的整数值 。也就是说，修订号 1 和修订号 001 相等 。
 * 如果版本号没有指定某个下标处的修订号，则该修订号视为 0 。
 * 例如，版本 1.0 小于版本 1.1 ，因为它们下标为 0 的修订号相同，而下标为 1 的修订号分别为 0 和 1 ，0 < 1 。
 * <p>
 * 返回规则如下：
 * 如果 version1 > version2 返回 1，
 * 如果 version1 < version2 返回 -1，
 * 除此之外返回 0。
 * <p>
 * 示例 1：
 * 输入：version1 = "1.01", version2 = "1.001"
 * 输出：0
 * 解释：忽略前导零，"01" 和 "001" 都表示相同的整数 "1"
 * <p>
 * 示例 2：
 * 输入：version1 = "1.0", version2 = "1.0.0"
 * 输出：0
 * 解释：version1 没有指定下标为 2 的修订号，即视为 "0"
 * <p>
 * 示例 3：
 * 输入：version1 = "0.1", version2 = "1.1"
 * 输出：-1
 * 解释：version1 中下标为 0 的修订号是 "0"，version2 中下标为 0 的修订号是 "1" 。0 < 1，所以 version1 < version2
 * <p>
 * 提示：
 * 1 <= version1.length, version2.length <= 500
 * version1 和 version2 仅包含数字和 '.'
 * version1 和 version2 都是 有效版本号
 * version1 和 version2 的所有修订号都可以存储在 32 位整数 中
 */
public class _165_比较版本号 {
    @Test
    public void T_0() {
        String[][] version = {{"1.1", "1.01.0"}, {"1", "1.1"}, {"1.0.1", "1"},
                {"1.01", "1.001"}, {"1.0", "1.0.0"}, {"0.1", "1.1"}};
        int[] ans = {0, -1, 1, 0, 0, -1};
        for (int i = 0; i < version.length; i++) {
            System.out.println(compareVersion(version[i][0], version[i][1]) == ans[i]);
        }
    }


    /*逐次比较每个小版本 没有版本号的就作为 0 */
    public int compareVersion(String version1, String version2) {
        String[] s1 = version1.split("\\.");
        String[] s2 = version2.split("\\.");
        int max = Math.max(s1.length, s2.length);
        for (int i = 0; i < max; i++) {
            int v1 = 0, v2 = 0;
            if (i < s1.length) {
                v1 = getVal(s1[i]);
            }
            if (i < s2.length) {
                v2 = getVal(s2[i]);
            }
            if (v1 != v2) {
                return v1 - v2 > 0 ? 1 : (v1 == v2 ? 0 : -1);
            }
        }
        return 0;
    }

    private int getVal(String s) {
        if (s.replaceAll("0", "").length() == 0) {
            return 0;
        }
        while (s.startsWith("0")) {
            s = s.substring(1);
        }
        return Integer.valueOf(s);
    }

    /*带字母的版本号 比较 小写字母 > 大写字母 > 数字  前导0去掉*/
    @Test
    public void T_() {
        String[][] s = {{"az.b.c", "a44444444444444.b.c"}, {"a.b.c", "a.b.d"}, {"5.6.1", "5.6.2a"}, {"5.6.8.a", "5.6.8.0a"}};
        int[] ans = {1, -1, -1, 0};
        for (int i = 0; i < s.length; i++) {
            System.out.println(compareVersion_od(s[i][0], s[i][1]) == ans[i]);
        }
    }

    private int compareVersion_od(String s1, String s2) {
        String[] ss1 = s1.split("\\.");
        String[] ss2 = s2.split("\\.");
        for (int i = 0; i < Math.max(ss1.length, ss2.length); i++) {
            String v1 = "0", v2 = "0";
            if (i < ss1.length) {
                v1 = getV(ss1[i]);
            }
            if (i < ss2.length) {
                v2 = getV(ss2[i]);
            }
            if (v1.compareTo(v2) != 0) {
                return v1.compareTo(v2) > 0 ? 1 : -1;
            }
        }
        return 0;
    }

    private String getV(String s) {
        if (s.replaceAll("0", "").length() == 0) {
            return "0";
        }
        while (s.startsWith("0")) {
            s = s.substring(1);
        }
        return s;
    }

    /**
    题目一：
    运维工程师采集到某产品线网运行一天产生的日志n条，现需根据日志时间先后顺序对日志进行排序，日志时间格式为H:M:S.N。
    H表示小时(0~23)
    M表示分钟(0~59)
    S表示秒(0~59)
    N表示毫秒(0~999)
    时间可能并没有补全，也就是说，01:01:01.001也可能表示为1:1:1.1。
    输入描述：
    第一行输入一个整数n表示日志条数，1<=n<=100000，接下来n行输入n个时间。
    输出描述：
    按时间升序排序之后的时间，如果有两个时间表示的时间相同，则保持输入顺序。
    示例：
    输入：
    2
    01:41:8.9
    1:1:09.211
    输出：
    1:1:09.211
    01:41:8.9
    输入：
    3
    23:41:08.023
    1:1:09.211
    08:01:22.0
    输出：
    1:1:09.211
    08:01:22.0
    23:41:08.023
    输入：
    2
    22:41:08.023
    22:41:08.23
    输出：
    22:41:08.023

    22:41:08.23
    * */
    @Test
    public void T_2(){
      String [][] diarys = {{"01:41:8.9","1:1:09.211"},
              {"23:41:08.023","1:1:09.211","08:01:22.0"},
              {"22:41:08.023","22:41:08.23"}};
      String [][] ans = {{"1:1:09.211","01:41:8.9"},
              {"1:1:09.211","08:01:22.0","23:41:08.023"},
              {"22:41:08.023","22:41:08.23"}};
        for (int i = 0; i < diarys.length; i++) {
            System.out.println(Arrays.equals(sortDiary(diarys[i]),ans[i]));
        }
    }

    private String[] sortDiary(String[] diary) {
        Arrays.sort(diary, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                o1 = o1.replace(".",":");
                o2 = o2.replace(".",":");
                String[] s1 = o1.split(":");
                String[] s2 = o2.split(":");
                for (int i = 0; i < s1.length; i++) {
                    int v1 = Integer.valueOf(s1[i]);
                    int v2 = Integer.valueOf(s2[i]);
                    if(v1 != v2){
                        return v1 - v2;
                    }
                }
                return 0;
            }
        });
        return diary;
    }
}
